home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Development / Source / MultiSession 1.04 Source / Core 27⁄June⁄1993 / CHScrollBar.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-06  |  10.3 KB  |  426 lines  |  [TEXT/KAHL]
  1. /* CHScrollBar.c */
  2.  
  3. #include "CHScrollBar.h"
  4. #include "CWindow.h"
  5.  
  6.  
  7. #define LeftArrowID (131)
  8. #define LeftArrowSelectedID (135)
  9. #define RightArrowID (130)
  10. #define RightArrowSelectedID (134)
  11.  
  12.  
  13. void            CHScrollBar::IHScrollBar(LongPoint Start, LongPoint Extent,
  14.                                 CViewRect* TheOwner, CWindow* TheWindow, CEnclosure* TheEnclosure)
  15.     {
  16.         Extent.y = 16;
  17.         Owner = TheOwner;
  18.         IViewRect(Start,Extent,TheWindow,TheEnclosure);
  19.         NumCells = 1;
  20.         CellIndex = 0;
  21.         RecalcScrollRects();
  22.         CurrentOperation = mNone;
  23.     }
  24.  
  25.  
  26. void            CHScrollBar::DoMouseDown(MyEventRec Event)
  27.     {
  28.         long                Length;
  29.         LongPoint        MouseLoc;
  30.         MyBoolean        OutOfRange;
  31.         short                XorPosition;
  32.         MyBoolean        ImageXored;
  33.  
  34.         CurrentOperation = FindPart(MyGlobalToLocal(Event.Where));
  35.         switch (CurrentOperation)
  36.             {
  37.                 case mLeftOne:
  38.                     if (HScrollable && Enabled)
  39.                         {
  40.                             do{
  41.                                     RedrawHBar();
  42.                                     if (CurrentOperation == mLeftOne)
  43.                                         {
  44.                                             Owner->Hook(HScrollLeftOne,0,0);
  45.                                         }
  46.                                     CurrentOperation = FindPart(MyGlobalToLocal(GetLongMouseLoc()));
  47.                                     if (CurrentOperation != mLeftOne)
  48.                                         {
  49.                                             CurrentOperation = mNone;
  50.                                         }
  51.                                     RelinquishCPU();
  52.                                     SendIdleToAll();
  53.                                 } while (WaitMouseUp());
  54.                             CurrentOperation = mNone;
  55.                             RedrawHBar();
  56.                         }
  57.                     break;
  58.                 case mLeftPage:
  59.                     if (HScrollable && Enabled)
  60.                         {
  61.                             do{
  62.                                     RedrawHBar();
  63.                                     if (CurrentOperation == mLeftPage)
  64.                                         {
  65.                                             Owner->Hook(HScrollLeftPage,0,0);
  66.                                         }
  67.                                     CurrentOperation = FindPart(MyGlobalToLocal(GetLongMouseLoc()));
  68.                                     if (CurrentOperation != mLeftPage)
  69.                                         {
  70.                                             CurrentOperation = mNone;
  71.                                         }
  72.                                     RelinquishCPU();
  73.                                     SendIdleToAll();
  74.                                 } while (WaitMouseUp());
  75.                             CurrentOperation = mNone;
  76.                             RedrawHBar();
  77.                         }
  78.                     break;
  79.                 case mRightOne:
  80.                     if (HScrollable && Enabled)
  81.                         {
  82.                             do{
  83.                                     RedrawHBar();
  84.                                     if (CurrentOperation == mRightOne)
  85.                                         {
  86.                                             Owner->Hook(HScrollRightOne,0,0);
  87.                                         }
  88.                                     CurrentOperation = FindPart(MyGlobalToLocal(GetLongMouseLoc()));
  89.                                     if (CurrentOperation != mRightOne)
  90.                                         {
  91.                                             CurrentOperation = mNone;
  92.                                         }
  93.                                     RelinquishCPU();
  94.                                     SendIdleToAll();
  95.                                 } while (WaitMouseUp());
  96.                             CurrentOperation = mNone;
  97.                             RedrawHBar();
  98.                         }
  99.                     break;
  100.                 case mRightPage:
  101.                     if (HScrollable && Enabled)
  102.                         {
  103.                             do{
  104.                                     RedrawHBar();
  105.                                     if (CurrentOperation == mRightPage)
  106.                                         {
  107.                                             Owner->Hook(HScrollRightPage,0,0);
  108.                                         }
  109.                                     CurrentOperation = FindPart(MyGlobalToLocal(GetLongMouseLoc()));
  110.                                     if (CurrentOperation != mRightPage)
  111.                                         {
  112.                                             CurrentOperation = mNone;
  113.                                         }
  114.                                     RelinquishCPU();
  115.                                     SendIdleToAll();
  116.                                 } while (WaitMouseUp());
  117.                             CurrentOperation = mNone;
  118.                             RedrawHBar();
  119.                         }
  120.                     break;
  121.                 case mHBox:
  122.                     if (HScrollable && Enabled)
  123.                         {
  124.                             if ((Event.Modifiers & optionKey) != 0)
  125.                                 {
  126.                                     short        OldMouseLoc = -32767;
  127.  
  128.                                     ImageXored = False;
  129.                                     /* setting up drawing environment */
  130.                                     SetUpPort();
  131.                                     Length = PageRightZoneExt.x + PageLeftZoneExt.x;
  132.                                     do{
  133.                                             static LongPoint    HXorBoxExt = {16,14};
  134.  
  135.                                             /* removing any image already there */
  136.                                             do
  137.                                                 {
  138.                                                     MouseLoc = MyGlobalToLocal(GetLongMouseLoc());
  139.                                                     RelinquishCPU();
  140.                                                     SendIdleToAll();
  141.                                                 } while ((MouseLoc.x - 16 - 8 == OldMouseLoc) && WaitMouseUp());
  142.                                             SetUpPort();
  143.                                             Window->ResetPen();
  144.                                             Window->SetPenMode(srcXor);
  145.                                             Window->SetPattern(dkGray);
  146.                                             if (ImageXored)
  147.                                                 {
  148.                                                     Window->LFrameRect(LongPointOf(XorPosition + 16,
  149.                                                         Extent.y - 16 + 1),HXorBoxExt);
  150.                                                     ImageXored = False;
  151.                                                 }
  152.                                             /* finding new image position */
  153.                                             OutOfRange = False;
  154.                                             OldMouseLoc = MouseLoc.x - 16 - 8;
  155.                                             XorPosition = OldMouseLoc;
  156.                                             if ((MouseLoc.y < Extent.y - 16 - 24)
  157.                                                 || (MouseLoc.y > Extent.y + 24))
  158.                                                 {
  159.                                                     OutOfRange = True;
  160.                                                 }
  161.                                             if (XorPosition < 0)
  162.                                                 {
  163.                                                     XorPosition = 0;
  164.                                                 }
  165.                                             if (XorPosition > Length)
  166.                                                 {
  167.                                                     XorPosition = Length;
  168.                                                 }
  169.                                             /* putting new image position */
  170.                                             if (!OutOfRange)
  171.                                                 {
  172.                                                     Window->LFrameRect(LongPointOf(XorPosition + 16,
  173.                                                         Extent.y - 16 + 1),HXorBoxExt);
  174.                                                     ImageXored = True;
  175.                                                 }
  176.                                             RelinquishCPU();
  177.                                             SendIdleToAll();
  178.                                             SetUpPort();
  179.                                         } while (WaitMouseUp());
  180.                                     if (ImageXored)
  181.                                         {
  182.                                             Owner->Hook(HScrollToLocation,
  183.                                                 ((NumCells - 1) * XorPosition) / Length,NumCells);
  184.                                         }
  185.                                 }
  186.                              else
  187.                                 {
  188.                                     do{
  189.                                             Length = PageLeftZoneExt.x + PageRightZoneExt.x;
  190.                                             MouseLoc = MyGlobalToLocal(GetLongMouseLoc());
  191.                                             MouseLoc.x = MouseLoc.x - 16 - 8;
  192.                                             if (MouseLoc.x < 0)
  193.                                                 {
  194.                                                     MouseLoc.x = 0;
  195.                                                 }
  196.                                             if (MouseLoc.x > Length)
  197.                                                 {
  198.                                                     MouseLoc.x = Length;
  199.                                                 }
  200.                                             Owner->Hook(HScrollToLocation,((NumCells - 1) * MouseLoc.x
  201.                                                 + (Length / 2)) / Length,NumCells);
  202.                                             RelinquishCPU();
  203.                                             SendIdleToAll();
  204.                                         } while (WaitMouseUp());
  205.                                 }
  206.                         }
  207.                     break;
  208.             }
  209.         CurrentOperation = mNone;
  210.     }
  211.  
  212.  
  213. short            CHScrollBar::FindPart(LongPoint Where)
  214.     {
  215.         if (LongPtInRect(Where,OneLeftZoneTL,OneLeftZoneExt))
  216.             {
  217.                 return mLeftOne;
  218.             }
  219.         if (LongPtInRect(Where,PageLeftZoneTL,PageLeftZoneExt))
  220.             {
  221.                 return mLeftPage;
  222.             }
  223.         if (LongPtInRect(Where,HScrollZoneTL,HScrollZoneExt))
  224.             {
  225.                 return mHBox;
  226.             }
  227.         if (LongPtInRect(Where,PageRightZoneTL,PageRightZoneExt))
  228.             {
  229.                 return mRightPage;
  230.             }
  231.         if (LongPtInRect(Where,OneRightZoneTL,OneRightZoneExt))
  232.             {
  233.                 return mRightOne;
  234.             }
  235.         return mNone;
  236.     }
  237.  
  238.  
  239. void            CHScrollBar::RedrawHBar(void)
  240.     {
  241.         SetUpPort();
  242.         Window->ResetPen();
  243.         if (Suspended || !Enabled)
  244.             {
  245.                 Window->LEraseRect(LongPointOf(1,1),LongPointOf(Extent.x - 2,Extent.y - 2));
  246.                 Window->LFrameRect(ZeroPoint,Extent);
  247.             }
  248.          else
  249.             {
  250.                 if (CurrentOperation == mLeftOne)
  251.                     {
  252.                         Window->LDrawPicture(GetPic(LeftArrowSelectedID),
  253.                             OneLeftZoneTL,OneLeftZoneExt);
  254.                     }
  255.                  else
  256.                     {
  257.                         Window->LDrawPicture(GetPic(LeftArrowID),
  258.                             OneLeftZoneTL,OneLeftZoneExt);
  259.                     }
  260.                 if (CurrentOperation == mRightOne)
  261.                     {
  262.                         Window->LDrawPicture(GetPic(RightArrowSelectedID),
  263.                             OneRightZoneTL,OneRightZoneExt);
  264.                     }
  265.                  else
  266.                     {
  267.                         Window->LDrawPicture(GetPic(RightArrowID),
  268.                             OneRightZoneTL,OneRightZoneExt);
  269.                     }
  270.                 if (HScrollable)
  271.                     {
  272.                         Window->SetPattern(ltGray);
  273.                         Window->LPaintRect(LongPointOf(PageLeftZoneTL.x,PageLeftZoneTL.y + 1),
  274.                             LongPointOf(PageLeftZoneExt.x,PageLeftZoneExt.y - 2));
  275.                         Window->LPaintRect(LongPointOf(PageRightZoneTL.x,PageRightZoneTL.y + 1),
  276.                             LongPointOf(PageRightZoneExt.x,PageRightZoneExt.y - 2));
  277.                         Window->SetPattern(black);
  278.                         Window->DrawLine(PageLeftZoneTL,LongPointOf(PageLeftZoneExt.x
  279.                             + HScrollZoneExt.x + PageRightZoneExt.x,0));
  280.                         Window->DrawLine(LongPointOf(PageLeftZoneTL.x,PageLeftZoneTL.y + 15),
  281.                             LongPointOf(PageLeftZoneExt.x + HScrollZoneExt.x + PageRightZoneExt.x,0));
  282.                         Window->LEraseRect(LongPointOf(HScrollZoneTL.x + 1,HScrollZoneTL.y + 1),
  283.                             LongPointOf(HScrollZoneExt.x - 2,HScrollZoneExt.y - 2));
  284.                         Window->LFrameRect(HScrollZoneTL,HScrollZoneExt);
  285.                     }
  286.                  else
  287.                     {
  288.                         Window->LEraseRect(LongPointOf(HScrollZoneTL.x,HScrollZoneTL.y + 1),
  289.                             LongPointOf(HScrollZoneExt.x,HScrollZoneExt.y - 2));
  290.                         Window->DrawLine(HScrollZoneTL,LongPointOf(HScrollZoneExt.x,0));
  291.                         Window->DrawLine(LongPointOf(HScrollZoneTL.x,HScrollZoneTL.y + 15),
  292.                             LongPointOf(HScrollZoneExt.x,0));
  293.                     }
  294.             }
  295.     }
  296.  
  297.  
  298. void            CHScrollBar::DoUpdate(void)
  299.     {
  300.         RedrawHBar();
  301.     }
  302.  
  303.  
  304. void            CHScrollBar::DoResume(void)
  305.     {
  306.         inherited::DoResume();
  307.         RedrawHBar();
  308.     }
  309.  
  310.  
  311. void            CHScrollBar::DoSuspend(void)
  312.     {
  313.         inherited::DoSuspend();
  314.         RedrawHBar();
  315.     }
  316.  
  317.  
  318. void            CHScrollBar::DoEnable(void)
  319.     {
  320.         inherited::DoEnable();
  321.         RedrawHBar();
  322.     }
  323.  
  324.  
  325. void            CHScrollBar::DoDisable(void)
  326.     {
  327.         inherited::DoDisable();
  328.         RedrawHBar();
  329.     }
  330.  
  331.  
  332.  
  333. void                CHScrollBar::RecalcScrollRects(void)
  334.     {
  335.         long        Length;
  336.         long        BoxPos;
  337.  
  338.         Length = Extent.x;
  339.         OneLeftZoneTL.y = Extent.y - 16;
  340.         OneLeftZoneTL.x = 0;
  341.         OneLeftZoneExt.y = 16;
  342.         OneLeftZoneExt.x = 16;
  343.         OneRightZoneTL.y = Extent.y - 16;
  344.         OneRightZoneTL.x = Length - 16;
  345.         OneRightZoneExt.y = 16;
  346.         OneRightZoneExt.x = 16;
  347.         if (NumCells <= 1)
  348.             {
  349.                 if (CellIndex == 0)
  350.                     {
  351.                         HScrollable = False;
  352.                         HScrollZoneTL.y = Extent.y - 16;
  353.                         HScrollZoneTL.x = 16;
  354.                         HScrollZoneExt.y = 16;
  355.                         HScrollZoneExt.x = Length - 16 - 16;
  356.                     }
  357.                  else
  358.                     {
  359.                         NumCells = -NumCells;
  360.                         goto TryAgainPoint;
  361.                     }
  362.             }
  363.          else
  364.             {
  365.              TryAgainPoint:
  366.                 HScrollable = True;
  367.                 if (NumCells == 1)
  368.                     {
  369.                         if (CellIndex < 0)
  370.                             {
  371.                                 BoxPos = 0;
  372.                             }
  373.                          else
  374.                             {
  375.                                 BoxPos = Length - 3*16;
  376.                             }
  377.                     }
  378.                  else
  379.                     {
  380.                         BoxPos = ((Length - 3*16)
  381.                             * ((long double)CellIndex) / ((long double)(NumCells - 1)));
  382.                         if (BoxPos < 0)
  383.                             {
  384.                                 BoxPos = 0;
  385.                             }
  386.                         if (BoxPos > Length - 3*16)
  387.                             {
  388.                                 BoxPos = Length - 3*16;
  389.                             }
  390.                     }
  391.                 PageLeftZoneTL.y = Extent.y - 16;
  392.                 PageLeftZoneTL.x = 16;
  393.                 PageLeftZoneExt.y = 16;
  394.                 PageLeftZoneExt.x = BoxPos;
  395.                 HScrollZoneTL.y = Extent.y - 16 + 1;
  396.                 HScrollZoneTL.x = BoxPos + 16;
  397.                 HScrollZoneExt.y = 14;
  398.                 HScrollZoneExt.x = 16;
  399.                 PageRightZoneTL.y = Extent.y - 16;
  400.                 PageRightZoneTL.x = BoxPos + 16 + 16;
  401.                 PageRightZoneExt.y = 16;
  402.                 PageRightZoneExt.x = (Length - 3*16) - BoxPos;
  403.             }
  404.     }
  405.  
  406.  
  407. void            CHScrollBar::SetPosition(long NewCellIndex, long NewNumCells)
  408.     {
  409.         CellIndex = NewCellIndex;
  410.         NumCells = NewNumCells;
  411.         RecalcScrollRects();
  412.         if ((!Suspended) && Enabled)
  413.             {
  414.                 RedrawHBar();
  415.             }
  416.     }
  417.  
  418.  
  419. void            CHScrollBar::RecalcLocations(LongPoint EnclosureVisRectStart,
  420.                         LongPoint EnclosureVisRectExtent, LongPoint EnclosureOrigin)
  421.     {
  422.         inherited::RecalcLocations(EnclosureVisRectStart,EnclosureVisRectExtent,
  423.             EnclosureOrigin);
  424.         RecalcScrollRects();
  425.     }
  426.